{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 量子神经网络模拟函数\n",
    "\n",
    "*Copyright (c) 2022 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 概览\n",
    "量子神经网络（Quantum Neural Network, QNN）由参数化量子电路组成，通过训练电路中的参数从而最小化目标损失函数，是一种常用的量子机器学习模型。和机器学习中的神经网络（Neural Network, NN）模型类似，QNN 的表达能力可以通过其能近似的函数来刻画。经典神经网络中的通用近似定理（Universal Approximation Theorem, UAT）描述了多层人工神经网络近似任意函数的能力。一些研究将 QNN 与傅里叶级数联系起来，发现多比特的 QNN 也有类似的通用近似性质（Universal Approximation Property, UAP）[1]，然而单比特 QNN 的表达能力仍旧是一个开放问题。我们从量子信号处理（Quantum Signal Processing, QSP）中获取灵感，建立了单比特 QNN 和单元傅里叶级数的一一对应关系，从而证明了单比特 QNN 的表达能力，解决了这个开放问题。在这篇教程中，我们将展示使用单比特 QNN 模拟任意目标函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 单比特 QNN 模拟任意偶函数\n",
    "我们使用 data re-uploading 形式的单比特 QNN，由数据编码门和可训练门交替组成，其中数据编码门和可训练门均从三种泡利旋转门$R_X,R_Y,R_Z$ 中选择。令 QNN 作用的初始态为 $|0\\rangle$，我们定义 QNN 的输出为对某个可观测量 $M$ 的测量，即\n",
    "\n",
    "$$\n",
    "f_U(x) = \\langle 0| U^\\dagger M U |0\\rangle, \\tag{1}\n",
    "$$\n",
    "\n",
    "其中 $x$ 为数据输入，$U$ 表示该 QNN。\n",
    "\n",
    "首先我们考虑最简单的情况，选择 $R_Z$ 为编码门，$R_Y$ 为可训练门，定义一种如下的 QNN：\n",
    "\n",
    "$$\n",
    "U^{\\mathit{YZY}}_{\\mathbf{\\theta}, L}(x) = R_Y(\\theta_0) \\sum_{j=1}^LR_Z(x)R_Y(\\theta_j), \\tag{2}\n",
    "$$\n",
    "\n",
    "其中 $\\mathbf{\\theta} := (\\theta_0, \\ldots, \\theta_L)$ 为可训练参数，$L$ 为 QNN 的层数。\n",
    "\n",
    "我们证明了这种单比特 QNN 可以表示傅里叶级数\n",
    "\n",
    "$$\n",
    "\\langle 0|U^{\\mathit{YZY}}_{\\mathbf{\\theta}, L}(x) |0\\rangle = a_0 + \\sum_{j=1}^{L}a_j\\cos(nx), \\tag{3}\n",
    "$$\n",
    "\n",
    "当选取可观测量为泡利算子 $Z$ 时，该 QNN 的输出也就能近似模拟任意平方可积的偶函数 $f: [-\\pi, \\pi] \\to [-1, 1]$。\n",
    "\n",
    "接下来我们使用量桨实现单比特 QNN 模拟偶函数的实验来验证以上结果。我们先通过下面几行代码引入必要的包。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import paddle\n",
    "import numpy as np\n",
    "import paddle_quantum\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "from paddle_quantum.hamiltonian import Hamiltonian\n",
    "from paddle_quantum.loss import ExpecVal\n",
    "import matplotlib.pyplot as plt\n",
    "import brewer2mpl\n",
    "import matplotlib\n",
    "# 设置后端为态矢量模式\n",
    "paddle_quantum.set_backend(\"state_vector\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们首先构造 QNN 对应的参数化量子电路，由数据编码门 $R_Z$ 和可训练门 $R_Y$ 组成。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 构造 YZY 结构的参数化量子电路\n",
    "def U_YZY(train_block, w_theta, x):\n",
    "    cir = Circuit(1)\n",
    "    for i in range(train_block):\n",
    "        cir.ry(0, param=w_theta[i])\n",
    "        cir.rz(0, param=x)  # 输入数据\n",
    "    cir.ry(0, param=w_theta[-1])\n",
    "    return cir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "选定模拟的目标函数为阻尼振荡函数 $f(x) = \\sin(5x)/5x$，我们需要从目标函数中采样获得数据点用于 QNN 的训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义目标函数\n",
    "def target_func(x):\n",
    "    return np.sin(5 * x) / (5 * x)\n",
    "\n",
    "# 随机采样获取关于目标函数的数据点\n",
    "def get_data():\n",
    "    x_plot = np.arange(0, np.pi, np.pi/1000)\n",
    "    y_plot = target_func(x_plot)\n",
    "    \n",
    "    np.random.seed(0)\n",
    "    x_all = np.random.uniform(0, np.pi, 300)\n",
    "    \n",
    "    y_all = np.sin(5*x_all) / (5*x_all)\n",
    "\n",
    "    x_train, y_train = x_all[:200], y_all[:200]\n",
    "    x_test, y_test = x_all[200:], y_all[200:]\n",
    "\n",
    "    return x_train, y_train, x_test, y_test, x_plot, y_plot\n",
    "    \n",
    "# 采样获取训练集和测试集\n",
    "x_train, y_train, x_test, y_test, x_plot, y_plot = get_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来定义 QNN 训练模型以及训练相关的函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QNN(paddle.nn.Layer):\n",
    "    def __init__(self, \n",
    "                 train_block,           # 电路的层数为 L\n",
    "                 SEED=0,\n",
    "                 dtype='float64'):\n",
    "        super(QNN, self).__init__()\n",
    "        self.train_block = train_block\n",
    "        paddle.seed(SEED)\n",
    "        # 初始化可训练参数\n",
    "        self.w_theta = self.create_parameter(\n",
    "            shape=[(train_block+1)],\n",
    "            default_initializer=paddle.nn.initializer.Uniform(0.0, 2 * np.pi),\n",
    "            dtype=dtype,\n",
    "            is_bias=False)\n",
    "\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        Forward propagation\n",
    "        \"\"\"\n",
    "        predict = []\n",
    "        H = Hamiltonian([(1.0, \"z0\")])\n",
    "        out_func = ExpecVal(H)\n",
    "        x = paddle.to_tensor(x, dtype='float64')\n",
    "        if len(x.shape) == 1:  # 对于 1 维数据进行处理\n",
    "            x = x.reshape((-1, 1))\n",
    "        for i in range(x.shape[0]):\n",
    "            cir = U_YZY(self.train_block, self.w_theta, x[i])\n",
    "            # 运行量子电路\n",
    "            out_state = cir()\n",
    "            predict.append(out_func(out_state))\n",
    "        return paddle.concat(predict).reshape((-1,)), cir\n",
    "\n",
    "\n",
    "# 训练函数\n",
    "def train_qnn(x, y, train_block, LR, ITR, SEED, BATCHSIZE=20):\n",
    "    model = QNN(train_block, SEED)\n",
    "    opt = paddle.optimizer.Adam(learning_rate=LR, parameters=model.parameters())\n",
    "    loss_list = []\n",
    "    x = paddle.to_tensor(x, dtype='float64')\n",
    "    y = paddle.to_tensor(y, dtype='float64')\n",
    "    for ep in range(1, ITR + 1):\n",
    "        # 对数据进行分批训练\n",
    "        for itr in range(len(x) // BATCHSIZE):\n",
    "            x_batch = x[itr * BATCHSIZE:(itr + 1) * BATCHSIZE]\n",
    "            y_batch = y[itr * BATCHSIZE:(itr + 1) * BATCHSIZE]\n",
    "            # 运行定义的量子神经网络\n",
    "            predict, cir = model(x_batch)\n",
    "            avg_loss = paddle.mean((predict - y_batch) ** 2)\n",
    "            loss_list.append(avg_loss.numpy())\n",
    "            # 计算梯度并进行优化\n",
    "            avg_loss.backward()\n",
    "            opt.minimize(avg_loss)\n",
    "            opt.clear_grad()\n",
    "            if (itr+1) % 5 == 0:\n",
    "                print(\"qnn:epoch:\", ep,\"qnn:iter:\", (itr+1), \" train  loss:\", \"%.8f\" % avg_loss.numpy())\n",
    "\n",
    "    return model, loss_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们使用层数为 10 的 QNN 来模拟目标函数，在训练前还需要设定一些有关优化器的超参数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\yuzhan01\\Miniconda3\\envs\\pq_new\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n",
      "c:\\Users\\yuzhan01\\Miniconda3\\envs\\pq_new\\lib\\site-packages\\paddle\\fluid\\framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  elif dtype == np.bool:\n",
      "c:\\Users\\yuzhan01\\Miniconda3\\envs\\pq_new\\lib\\site-packages\\paddle\\fluid\\dygraph\\math_op_patch.py:276: UserWarning: The dtype of left and right variables are not the same, left dtype is paddle.float32, but right dtype is paddle.float64, the right dtype will convert to paddle.float32\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "qnn:epoch: 1 qnn:iter: 5  train  loss: 0.12315345\n",
      "qnn:epoch: 1 qnn:iter: 10  train  loss: 0.06922857\n",
      "qnn:epoch: 2 qnn:iter: 5  train  loss: 0.02042443\n",
      "qnn:epoch: 2 qnn:iter: 10  train  loss: 0.04707706\n",
      "qnn:epoch: 3 qnn:iter: 5  train  loss: 0.01874223\n",
      "qnn:epoch: 3 qnn:iter: 10  train  loss: 0.01295448\n",
      "qnn:epoch: 4 qnn:iter: 5  train  loss: 0.00991240\n",
      "qnn:epoch: 4 qnn:iter: 10  train  loss: 0.00303511\n",
      "qnn:epoch: 5 qnn:iter: 5  train  loss: 0.00157935\n",
      "qnn:epoch: 5 qnn:iter: 10  train  loss: 0.00089821\n",
      "qnn:epoch: 6 qnn:iter: 5  train  loss: 0.00046386\n",
      "qnn:epoch: 6 qnn:iter: 10  train  loss: 0.00054655\n",
      "qnn:epoch: 7 qnn:iter: 5  train  loss: 0.00059435\n",
      "qnn:epoch: 7 qnn:iter: 10  train  loss: 0.00022313\n",
      "qnn:epoch: 8 qnn:iter: 5  train  loss: 0.00028409\n",
      "qnn:epoch: 8 qnn:iter: 10  train  loss: 0.00017835\n",
      "qnn:epoch: 9 qnn:iter: 5  train  loss: 0.00017996\n",
      "qnn:epoch: 9 qnn:iter: 10  train  loss: 0.00018871\n",
      "qnn:epoch: 10 qnn:iter: 5  train  loss: 0.00016455\n",
      "qnn:epoch: 10 qnn:iter: 10  train  loss: 0.00012700\n"
     ]
    }
   ],
   "source": [
    "SEED = 4096\n",
    "QITR = 10\n",
    "QLR = 0.1\n",
    "train_block = 10\n",
    "modelL10, loss_listL10 = train_qnn(x_train, y_train, train_block=train_block, LR=QLR, ITR=QITR, SEED=SEED)\n",
    "predictL10 = modelL10(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练完成后，以图像形式展示函数模拟的结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "matplotlib.rcParams[\"font.family\"] = \"serif\"\n",
    "matplotlib.rcParams[\"mathtext.fontset\"] = \"cm\"\n",
    "bmap = brewer2mpl.get_map(\"Set1\", \"qualitative\", 7)\n",
    "colors = bmap.mpl_colors\n",
    "\n",
    "plt.plot(x_plot, y_plot, color=\"#304860\", ls=\"--\", lw=2.5, label=\"Target function\")\n",
    "\n",
    "plt.scatter(\n",
    "        x_test,\n",
    "        predictL10[0].numpy(),\n",
    "        s=40,\n",
    "        marker=\"^\",\n",
    "        facecolor=\"white\",\n",
    "        color=\"#D1193E\",\n",
    "        label=\"QNN L=10\",\n",
    "    )\n",
    "plt.xlabel(r\"$x$\", fontdict={\"size\": 22})\n",
    "plt.ylabel(r\"$f(x)$\", fontdict={\"size\": 22})\n",
    "plt.xticks(fontsize=10)\n",
    "plt.yticks(fontsize=10)\n",
    "plt.legend(prop={\"size\": 12})\n",
    "plt.text(0, -0.2, r\"(a)\", fontsize=16)\n",
    "plt.tick_params(labelsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从结果可以看出，使用层数为 10 的 QNN 能以较高精度近似目标函数，验证了关于 QNN 表达能力的理论结果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 单比特 QNN 模拟任意函数\n",
    "既然 $U^{\\mathit{YZY}}_{\\mathbf{\\theta}, L}$ 可以模拟任意偶函数，那么有没有办法可以做出一些修改，使得 QNN 可以模拟任意的函数呢？实际上，我们只需要在 $U^{\\mathit{YZY}}_{\\mathbf{\\theta}, L}$ 对应的仅含 $\\cos$ 项的傅里叶级数的基础上，引入 $\\sin$ 项即可得到完整的傅里叶级数。具体的，我们需要加入额外的可训练门 $R_Z$，定义一种如下的 QNN:\n",
    "\n",
    "$$\n",
    "U^{\\mathit{WZW}}_{\\mathbf{\\theta},\\mathbf{\\phi}, L}(x) = R_Y(\\theta_0)R_Z(\\phi_0) \\sum_{j=1}^L R_Z(x) R_Y(\\theta_j)R_Z(\\phi_j), \\tag{4}\n",
    "$$\n",
    "\n",
    "其中 $\\mathbf{\\theta} := (\\theta_0, \\ldots, \\theta_L)$ 和 $\\mathbf{\\phi} := (\\phi_0, \\ldots, \\phi_L)$ 为可训练参数，$L$ 为 QNN 的层数。我们证明了这种单比特 QNN 可以表示傅里叶级数\n",
    "\n",
    "$$\n",
    "\\langle 0|U^{\\mathit{WZW}}_{\\mathbf{\\theta},\\mathbf{\\phi}, L}(x) |0\\rangle = a_0 + \\sum_{j=1}^{L}(a_j\\cos(nx)+ b_j\\sin(nx)), \\tag{5}\n",
    "$$\n",
    "\n",
    "从而能够近似模拟任意平方可积的函数 $f: [-\\pi, \\pi] \\to [-1, 1]$。\n",
    "\n",
    "接下来我们使用量桨实现单比特 QNN 模拟方波函数的实验来验证以上结果。首先构造 $U^{\\mathit{WZW}}_{\\mathbf{\\theta},\\mathbf{\\phi}, L}$ 形式的 QNN 对应的参数化量子电路。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def U_WZW(train_block, w_theta, x):\n",
    "    cir = Circuit(1)\n",
    "    for i in range(train_block):\n",
    "        cir.rz(0, param=w_theta[i][1])\n",
    "        cir.ry(0, param=w_theta[i][0])\n",
    "        cir.rz(0, param=x)  # 输入数据\n",
    "    cir.rz(0, param=w_theta[-1][1])\n",
    "    cir.ry(0, param=w_theta[-1][0])\n",
    "    return cir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "与前一章节类似，我们需要定义模拟的目标函数，并从目标函数中采样获得数据点用于 QNN 的训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square_wave(trunk):\n",
    "    x_train = np.linspace(0, 20, 400)\n",
    "    x_test = np.linspace(0.02, 30, 150)\n",
    "\n",
    "    def func(x):\n",
    "        cof = 0\n",
    "        for i in range(1, trunk+1, 2):\n",
    "            cof = cof + 4*np.sin(i*x)/(i*np.pi)\n",
    "        y_max = max(cof)\n",
    "        cof /= y_max\n",
    "        return cof\n",
    "    \n",
    "    y_train = func(x_train)\n",
    "    y_test = func(x_test)\n",
    "\n",
    "    return x_train, y_train, x_test, y_test\n",
    "\n",
    "x_train, y_train, x_test, y_test = square_wave(10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来根据 QNN 结构定义其训练模型以及训练相关的函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QNN(paddle.nn.Layer):\n",
    "    def __init__(self, \n",
    "                 train_block,           # 电路的层数为 L\n",
    "                 SEED=0,\n",
    "                 dtype='float64'):\n",
    "        super(QNN, self).__init__()\n",
    "        self.train_block = train_block\n",
    "        paddle.seed(SEED)\n",
    "        # 初始化可训练参数\n",
    "        self.w_theta = self.create_parameter(\n",
    "            shape=[(train_block+1), 2],\n",
    "            default_initializer=paddle.nn.initializer.Uniform(0.0, 2*np.pi),\n",
    "            dtype=dtype,\n",
    "            is_bias=False)\n",
    "\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        Forward propagation\n",
    "        \"\"\"\n",
    "        predict = []\n",
    "        H = Hamiltonian([(1.0, \"z0\")])\n",
    "        out_func = ExpecVal(H)\n",
    "        x = paddle.to_tensor(x, dtype='float64')\n",
    "        if len(x.shape) == 1:  # 对于 1 维数据进行处理\n",
    "            x = x.reshape((-1, 1))\n",
    "        for i in range(x.shape[0]):\n",
    "            cir = U_WZW(self.train_block, self.w_theta, x[i])\n",
    "            # 运行量子电路\n",
    "            out_state = cir()\n",
    "            predict.append(out_func(out_state))\n",
    "        return paddle.concat(predict).reshape((-1,)), cir\n",
    "\n",
    "\n",
    "# 定义训练函数\n",
    "def train_qnn(x, y, train_block, LR, ITR, SEED, BATCHSIZE=40):\n",
    "    model = QNN(train_block, SEED)\n",
    "    opt = paddle.optimizer.Adam(learning_rate=LR, parameters=model.parameters())\n",
    "    loss_list = []\n",
    "    x = paddle.to_tensor(x, dtype='float64')\n",
    "    y = paddle.to_tensor(y, dtype='float64')\n",
    "    for ep in range(1, ITR + 1):\n",
    "        # 对数据进行分批训练\n",
    "        for itr in range(len(x) // BATCHSIZE):\n",
    "            x_batch = x[itr * BATCHSIZE:(itr + 1) * BATCHSIZE]\n",
    "            y_batch = y[itr * BATCHSIZE:(itr + 1) * BATCHSIZE]\n",
    "            # 运行上面定义的量子神经网络\n",
    "            predict, cir = model(x_batch)\n",
    "            avg_loss = paddle.mean((predict - y_batch) ** 2)\n",
    "            loss_list.append(avg_loss.numpy())\n",
    "            # 计算梯度并进行优化\n",
    "            avg_loss.backward()\n",
    "            opt.minimize(avg_loss)\n",
    "            opt.clear_grad()\n",
    "            if (itr+1) % 5 == 0:\n",
    "                print(\"qnn:epoch:\", ep,\"qnn:iter:\", (itr+1), \" train  loss:\", \"%.8f\" % avg_loss.numpy())\n",
    "\n",
    "    return model, loss_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们使用层数为 45 的 QNN 来模拟该方波函数，注意这里使用的层数与目标函数的傅里叶截断误差有关，通常来说对于越复杂的函数使用的层数越多，使用的层数越多模拟的效果越好。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\yuzhan01\\Miniconda3\\envs\\pq_new\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n",
      "c:\\Users\\yuzhan01\\Miniconda3\\envs\\pq_new\\lib\\site-packages\\paddle\\fluid\\framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  elif dtype == np.bool:\n",
      "c:\\Users\\yuzhan01\\Miniconda3\\envs\\pq_new\\lib\\site-packages\\paddle\\fluid\\dygraph\\math_op_patch.py:276: UserWarning: The dtype of left and right variables are not the same, left dtype is paddle.float32, but right dtype is paddle.float64, the right dtype will convert to paddle.float32\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "qnn:epoch: 1 qnn:iter: 5  train  loss: 1.35621011\n",
      "qnn:epoch: 1 qnn:iter: 10  train  loss: 1.06700826\n",
      "qnn:epoch: 2 qnn:iter: 5  train  loss: 1.59428942\n",
      "qnn:epoch: 2 qnn:iter: 10  train  loss: 0.32698074\n",
      "qnn:epoch: 3 qnn:iter: 5  train  loss: 0.30190033\n",
      "qnn:epoch: 3 qnn:iter: 10  train  loss: 0.09284516\n",
      "qnn:epoch: 4 qnn:iter: 5  train  loss: 0.11605076\n",
      "qnn:epoch: 4 qnn:iter: 10  train  loss: 0.06084419\n",
      "qnn:epoch: 5 qnn:iter: 5  train  loss: 0.10283329\n",
      "qnn:epoch: 5 qnn:iter: 10  train  loss: 0.07899086\n",
      "qnn:epoch: 6 qnn:iter: 5  train  loss: 0.06403162\n",
      "qnn:epoch: 6 qnn:iter: 10  train  loss: 0.05624062\n",
      "qnn:epoch: 7 qnn:iter: 5  train  loss: 0.05701165\n",
      "qnn:epoch: 7 qnn:iter: 10  train  loss: 0.05501990\n",
      "qnn:epoch: 8 qnn:iter: 5  train  loss: 0.05415571\n",
      "qnn:epoch: 8 qnn:iter: 10  train  loss: 0.05919911\n",
      "qnn:epoch: 9 qnn:iter: 5  train  loss: 0.05508716\n",
      "qnn:epoch: 9 qnn:iter: 10  train  loss: 0.05666707\n",
      "qnn:epoch: 10 qnn:iter: 5  train  loss: 0.05592950\n",
      "qnn:epoch: 10 qnn:iter: 10  train  loss: 0.05661748\n"
     ]
    }
   ],
   "source": [
    "SEED = 2\n",
    "QITR = 10\n",
    "QLR = 0.1\n",
    "train_block = 45\n",
    "modelL45, loss_listL45 = train_qnn(x_train, y_train, train_block=train_block, LR=QLR, ITR=QITR, SEED=SEED)\n",
    "predictL45 = modelL45(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后我们作图展示函数模拟的结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax1 = plt.subplots(1, 1,figsize=(10,6))\n",
    "ax1.plot(x_train, y_train, label='Target function', color='#000181', lw=2, linestyle='--')\n",
    "ax1.plot(x_test, predictL45[0].numpy(), label='QNN L=45', color='#AE2D68', lw=2,linestyle='-')\n",
    "ax1.axvline(20, alpha=0.7,ls='--',c='#280659')\n",
    "ax1.set_xlabel(r'$x$', fontdict={'size':22})\n",
    "ax1.set_ylabel(r'$f(x)$', fontdict={'size':22})\n",
    "plt.tick_params(labelsize=16)\n",
    "ax1.legend(prop={'size': 12})\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由结果可以看出，即使是方波这种对于经典 NN 而言难以模拟的函数，使用 QNN 也可以达到良好的近似效果，验证了 QNN 的表达能力。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 参考文献\n",
    "\n",
    "[1] Schuld, Maria, Ryan Sweke, and Johannes Jakob Meyer. \"Effect of data encoding on the expressive power of variational quantum-machine-learning models.\" [Physical Review A 103.3 (2021): 032430.](https://doi.org/10.1103/PhysRevA.103.032430)\n",
    "\n",
    "[2] Yu, Zhan, et al. \"Power and limitations of single-qubit native quantum neural networks.\" [arXiv preprint arXiv:2205.07848 (2022).](https://doi.org/10.48550/arXiv.2205.07848)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.13 ('pq')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "08942b1340a5932ff3a93f52933a99b0e263568f3aace1d262ffa4d9a0f2da31"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
